//package com.itstyle.seckill.common.aop;
//
//import java.util.concurrent.locks.Lock;
//import java.util.concurrent.locks.ReentrantLock;
//
//import org.aspectj.lang.ProceedingJoinPoint;
//import org.aspectj.lang.annotation.Around;
//import org.aspectj.lang.annotation.Aspect;
//import org.aspectj.lang.annotation.Pointcut;
//import org.springframework.context.annotation.Scope;
//import org.springframework.core.annotation.Order;
//import org.springframework.stereotype.Component;
///**
// * 同步锁 AOP
// * 创建者	张志朋
// * 创建时间	2015年6月3日
// * @transaction 中  order 大小的说明
// * https://docs.spring.io/spring/docs/4.3.14.RELEASE/spring-framework-reference/htmlsingle/#transaction-declarative-annotations
// * https://docs.spring.io/spring/docs/4.3.14.RELEASE/javadoc-api/
// */
//@Component
//@Scope
//@Aspect
//@Order(1)
////order越小越是最先执行，但更重要的是最先执行的最后结束。order默认值是2147483647
//public class LockAspect {
//	/**
//     * 思考：为什么不用synchronized
//     * service 默认是单例的，并发下lock只有一个实例
//     */
//	private static  Lock lock = new ReentrantLock(true);//互斥锁 参数默认false，不公平锁
//
//	//Service层切点     用于记录错误日志
//	@Pointcut("@annotation(com.itstyle.seckill.common.aop.Servicelock)")
//	public void lockAspect() {
//
//	}
//
//    @Around("lockAspect()")
//    public  Object around(ProceedingJoinPoint joinPoint) {
//    	lock.lock();
//    	Object obj = null;
//		try {
//			obj = joinPoint.proceed();
//		} catch (Throwable e) {
//			e.printStackTrace();
//			throw new RuntimeException();
//		} finally{
//			lock.unlock();
//		}
//    	return obj;
//    }
//}

package com.itstyle.seckill.common.aop;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

import com.itstyle.seckill.distributedlock.redis.RedissLockUtil;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.context.annotation.Scope;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
/**
 * 同步锁 AOP
 * 创建者	张志朋
 * 创建时间	2015年6月3日
 * @transaction 中  order 大小的说明
 * https://docs.spring.io/spring/docs/4.3.14.RELEASE/spring-framework-reference/htmlsingle/#transaction-declarative-annotations
 * https://docs.spring.io/spring/docs/4.3.14.RELEASE/javadoc-api/
 */
@Component
@Scope
@Aspect
@Order(1)
//order越小越是最先执行，但更重要的是最先执行的最后结束。order默认值是2147483647
public class LockAspect {
	/**
	 * 思考：为什么不用synchronized
	 * service 默认是单例的，并发下lock只有一个实例
	 */
	private static  Lock lock = new ReentrantLock(true);//互斥锁 参数默认false，不公平锁

	//Service层切点     用于记录错误日志
	@Pointcut("@annotation(com.itstyle.seckill.common.aop.Servicelock)")
	public void lockAspect() {

	}

	@Around("lockAspect()")
	public  Object around(ProceedingJoinPoint joinPoint) {
		Object[] args = joinPoint.getArgs();
		Boolean ret = RedissLockUtil.tryLock(args[0].toString(),0,10);
		Object obj = null;
		try {
			obj = joinPoint.proceed();
		} catch (Throwable e) {
			e.printStackTrace();
			throw new RuntimeException();
		} finally{
			if(ret)
				RedissLockUtil.unlock(args[0].toString());
		}
		return obj;

//		if (!Thread.currentThread().isInterrupted()) {
//			System.out.println(Thread.currentThread().getName() + " gets lock.");
//			try {
//				obj = joinPoint.proceed();
//			} catch (InterruptedException e) {
//				Thread.currentThread().interrupt();
//			} finally {
//				if(isLock)
//					lock.unlock();
//			}
//		} else {
//			System.out.println(Thread.currentThread().getName() + " does not get lock.");
//		}
	}
}

//
//package com.itstyle.seckill.common.aop;
//
//import java.util.concurrent.TimeUnit;
//import java.util.concurrent.locks.Lock;
//import java.util.concurrent.locks.ReentrantLock;
//
//import com.itstyle.seckill.common.exception.RrException;
//import com.itstyle.seckill.distributedlock.redis.RedissLockUtil;
//import org.aspectj.lang.ProceedingJoinPoint;
//import org.aspectj.lang.annotation.Around;
//import org.aspectj.lang.annotation.Aspect;
//import org.aspectj.lang.annotation.Pointcut;
//import org.redisson.api.RLock;
//import org.redisson.api.RedissonClient;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.context.annotation.Scope;
//import org.springframework.core.annotation.Order;
//import org.springframework.stereotype.Component;
///**
// * 同步锁 AOP
// * 创建者	张志朋
// * 创建时间	2015年6月3日
// * @transaction 中  order 大小的说明
// * https://docs.spring.io/spring/docs/4.3.14.RELEASE/spring-framework-reference/htmlsingle/#transaction-declarative-annotations
// * https://docs.spring.io/spring/docs/4.3.14.RELEASE/javadoc-api/
// */
//@Component
//@Scope
//@Aspect
//@Order(1)
////order越小越是最先执行，但更重要的是最先执行的最后结束。order默认值是2147483647
//public class LockAspect {
//	/**
//     * 思考：为什么不用synchronized
//     * service 默认是单例的，并发下lock只有一个实例
//     */
//	private static  Lock lock = new ReentrantLock(true);//互斥锁 参数默认false，不公平锁
//
//	@Autowired
//	private RedissonClient redissonClient;
//
//	//Service层切点     用于记录错误日志
//	@Pointcut("@annotation(com.itstyle.seckill.common.aop.Servicelock)")
//	public void lockAspect() {
//
//	}
//
//    @Around("lockAspect()")
//    public  Object around(ProceedingJoinPoint joinPoint) {
//		boolean isLock=false;
//		Object obj = null;
//		Object[] args = joinPoint.getArgs();
//		System.out.println(Thread.currentThread().getName() +"加锁" + args[1].toString());
//		RLock lock = redissonClient.getLock(args[0].toString()+"");
//
//
//
//		try {
//
//			isLock = lock.tryLock(3, 10,TimeUnit.SECONDS);
//
//			if (!Thread.currentThread().isInterrupted()) {
//				System.out.println(Thread.currentThread().getName() + " gets lock.");
//				try {
//					obj = joinPoint.proceed();
//				} catch (InterruptedException e) {
//					Thread.currentThread().interrupt();
//				} finally {
//					if(isLock)
//						lock.unlock();
//				}
//			} else {
//				System.out.println(Thread.currentThread().getName() + " does not get lock.");
//			}
//
////			System.out.println(Thread.currentThread().getName() + "|" + args[1].toString() + "持锁："  + isLock);
//		} catch (Throwable throwable) {
//			throwable.printStackTrace();
//		}
////		finally{
////			System.out.println(Thread.currentThread().getName() +"释放锁");
////			if(lock.isLocked()){
////				if(lock.isHeldByCurrentThread()){
////					lock.unlock();
////				}
////			}
////		}
//    	return obj;
//    }
//}
